package socks

import (
	"bufio"
	"io"
)

type DataReceiver = io.ReaderFrom

type SockEventProc func(conn *SockConn)
type NewConnDataReceiverFun func(conn *SockConn) DataReceiver // 创建 Writer 每个连接一个，不能共用一个

type SockEvents struct {
	ConnectHandler    SockEventProc
	SocketReadHnalder func(conn *SockConn, reader *bufio.Reader)
	DisconectHandler  SockEventProc
	ErrorHandler      func(conn *SockConn, err error) error // 如果错误没处理，将关闭连接
}

type sockBase struct {
	SockEvents
}

type sockOwner interface {
	procSockError(conn *SockConn, err error) error
	procConnect(conn *SockConn)
	procDisconnect(conn *SockConn)
	procSocketRead(conn *SockConn)
	getSockBase() *sockBase
	SendQueueDatas() // 异步发送数据
	Open() error
	Close()
}

func (s *sockBase) getSockBase() *sockBase {
	return s
}

func (s *sockBase) procSockError(conn *SockConn, err error) error {
	if s.ErrorHandler != nil {
		return s.ErrorHandler(conn, err)
	}
	return err
}

func (s *sockBase) procConnect(conn *SockConn) {
	if s.ConnectHandler != nil {
		s.ConnectHandler(conn)
	}
}

func (s *sockBase) procDisconnect(conn *SockConn) {
	if s.DisconectHandler != nil {
		s.DisconectHandler(conn)
	}
}

func (s *sockBase) procSocketRead(conn *SockConn) {
	if s.SocketReadHnalder != nil {
		s.SocketReadHnalder(conn, conn.readBuff)
	}
}

func process_connection(s sockOwner, conn *SockConn) {

	defer func() {
		conn.Disconnect()
		s.procDisconnect(conn)
	}()

	s.procConnect(conn)

	s.procSocketRead(conn)
}
